home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / APPLICAT / C034.ZIP / DBQTUP.C < prev    next >
Text File  |  2010-11-01  |  9KB  |  498 lines
  1. /*    SDB - operations on tuples        */
  2.  
  3. #include "bdscio.h"
  4. #include "dbqdefs.h"
  5.  
  6. int insert()
  7. {
  8.     struct scan *sptr;
  9.     struct attribute *aptr;
  10.     char aname[ANSIZE+1],avalue[STRINGMAX+1];
  11.     int tcnt,astart,i;
  12.  
  13.     if (db_token() == ID)
  14.         db_ntoken();
  15.     else
  16.         strcpy(dbv_tstring,"current");
  17.  
  18.     if (!db_flush(0))
  19.         return (FALSE);
  20.  
  21.     if (!(sptr = db_ropen(dbv_tstring)))
  22.         return (FALSE);
  23.  
  24.     for (tcnt = 0; ; tcnt++) {
  25.  
  26.         if (tcnt)
  27.             printf("----\n");
  28.  
  29.         astart = 1;
  30.         for (i = 0; i < NATTRS; i++) {
  31.             aptr = &sptr->sc_relation->rl_header.hd_attrs[i];
  32.  
  33.             if (!aptr->at_name[0])
  34.                 break;
  35.  
  36.             strncpy(aname,aptr->at_name,ANSIZE);
  37.             aname[ANSIZE] = 0;
  38.  
  39.             db_prompt(NULL,NULL);
  40.  
  41.             while (TRUE) {
  42.                 if (!dbv_ifp) {
  43.                     if (strlen(aname) < 8)
  44.                         printf("%s\t\t",aname);
  45.                     else
  46.                         printf("%s\t",aname);
  47.                     inbrack(aptr->at_size,aptr->at_type,aptr->at_scale);
  48.                     }
  49.                 if (db_gline(avalue))
  50.                     break;
  51.             }
  52.  
  53.             if (!i && !avalue[0])
  54.                 break;
  55.  
  56.             db_aput(aptr,&sptr->sc_tuple[astart],avalue);
  57.  
  58.             astart += aptr->at_size;
  59.         }
  60.  
  61.         if (!avalue[0])
  62.             break;
  63.  
  64.         if (!db_rstore(sptr)) {
  65.             db_rclose(sptr);
  66.             return (FALSE);
  67.         }
  68.     }
  69.  
  70.     db_rclose(sptr);
  71.  
  72.     pcount(tcnt,"inserted");
  73.  
  74.     return (TRUE);
  75. }
  76.  
  77. int delete()
  78. {
  79.     struct sel *slptr;
  80.     struct srel *srptr;
  81.     int tcnt;
  82.  
  83.     if (!(slptr = db_retrieve(NULL)))
  84.         return (FALSE);
  85.  
  86.     for (tcnt = 0; db_fetch(slptr); tcnt++)
  87.  
  88.         for (srptr = slptr->sl_rels; srptr != NULL;srptr = srptr->sr_next)
  89.             if (!db_rdelete(srptr->sr_scan)) {
  90.                 db_done(slptr);
  91.                 return (FALSE);
  92.             }
  93.     db_done(slptr);
  94.  
  95.     pcount(tcnt,"deleted");
  96.  
  97.     return (TRUE);
  98. }
  99.  
  100. int update()
  101. {
  102.     struct sel *slptr;
  103.     struct sattr *saptr;
  104.     struct attribute *aptr;
  105.     char aname[ANSIZE+1],avalue[STRINGMAX+1],*ap;
  106.     int tcnt;
  107.  
  108.     if (!(slptr = db_select(NULL)))
  109.         return (FALSE);
  110.  
  111.     if (!db_flush(0)) {
  112.         db_done(slptr);
  113.         return (FALSE);
  114.     }
  115.  
  116.     for (tcnt = 0; db_fetch(slptr); tcnt++) {
  117.         if (tcnt)
  118.             printf("----\n");
  119.  
  120.         for (saptr = slptr->sl_attrs; saptr ; saptr = saptr->sa_next) {
  121.  
  122.             aptr = saptr->sa_attr;
  123.  
  124.             strncpy(aname,aptr->at_name,ANSIZE);
  125.             aname[ANSIZE] = 0;
  126.  
  127.             db_aget(aptr,saptr->sa_aptr,avalue);
  128.             for (ap = avalue; isspace(*ap); ap++)
  129.                 ;
  130.  
  131.             if (!dbv_ifp)
  132.               if (strlen(aname) < 8)
  133.                 printf("%s\t\t= %s\n",aname,ap); 
  134.               else
  135.                 printf("%s\t= %s\n",aname,ap); 
  136.  
  137.             db_prompt(NULL,NULL);
  138.  
  139.             while (TRUE) {
  140.                 if (!dbv_ifp) {
  141.                    if (strlen(aname) < 8)
  142.                     printf("%s\t\t ",aname);
  143.                    else
  144.                     printf("%s\t ",aname);
  145.                    inbrack(aptr->at_size,aptr->at_type,aptr->at_scale);
  146.                    }
  147.                 if (db_gline(avalue))
  148.                     break;
  149.             }
  150.  
  151.             if (avalue[0]) {
  152.                 db_aput(aptr,saptr->sa_aptr,avalue);
  153.                 saptr->sa_srel->sr_update = TRUE;
  154.             }
  155.         }
  156.  
  157.         db_update(slptr);
  158.     }
  159.  
  160.     db_done(slptr);
  161.  
  162.     pcount(tcnt,"updated");
  163.  
  164.     return (TRUE);
  165. }
  166.  
  167. inbrack(fldsize,fldtype,fldscale)
  168. int fldsize,fldscale; char fldtype;
  169. {
  170.     int i;
  171.  
  172.     i = fldsize;
  173.     if (fldtype == TNUM)
  174.         putchar('<');
  175.     else
  176.         putchar('[');
  177.     while (i--) putchar(' ');
  178.     if (fldtype == TNUM) {
  179.         putchar('>');
  180.         if (fldscale) printf(" %d\b\b",fldscale);
  181.     }
  182.     else
  183.         putchar(']');
  184.     putchar('\b');
  185.     while (fldsize--) putchar('\b');
  186. }
  187.  
  188. int print()
  189. {
  190.     struct sel *slptr;
  191.     char *ffp;
  192.     FILE *ofp;
  193.     int tcnt;
  194.  
  195.     if (!using(&ffp,".fmt"))
  196.         return (FALSE);
  197.  
  198.     if (!(slptr = db_select(NULL)))
  199.         return (FALSE);
  200.  
  201.     if (!db_to(&ofp,".rep")) {
  202.         db_done(slptr);
  203.         return (FALSE);
  204.     }
  205.  
  206.     dbv_page = 0;
  207.     dbv_lnct = dbv_pgln;
  208.  
  209.     if (ffp)
  210.         tcnt = form(ofp,slptr,ffp);
  211.     else
  212.         tcnt = table(ofp,slptr);
  213.  
  214.     db_done(slptr);
  215.  
  216.     if (ffp) {
  217.         CFREE(ffp);
  218.         }
  219.  
  220.     if (ofp != STDOUT) {
  221.         putc(CPMEOF,ofp);
  222.         fclose(ofp);
  223.         }
  224.  
  225.     pcount(tcnt,"found");
  226.  
  227.     return (TRUE);
  228. }
  229.  
  230. int select()
  231. {
  232.     struct sel *slptr;
  233.     struct relation *rptr;
  234.     struct sattr *saptr;
  235.     char *aname,*tbuf;
  236.     int tcnt,abase,i;
  237.  
  238.     if (!(slptr = db_select(NULL)))
  239.         return (FALSE);
  240.  
  241.     if (!(rptr = db_rcreate("current"))) {
  242.         db_done(slptr);
  243.         return(FALSE);
  244.     }
  245.  
  246.     for (saptr = slptr->sl_attrs; saptr; saptr = saptr->sa_next) {
  247.  
  248.         if (!(aname = saptr->sa_name))
  249.             aname = saptr->sa_aname;
  250.  
  251.         if (!db_rcattr(rptr,aname,saptr->sa_attr->at_type,
  252.            saptr->sa_attr->at_size,saptr->sa_attr->at_scale)) {
  253.  
  254.             CFREE(rptr);
  255.             db_done(slptr);
  256.             return (FALSE);
  257.         }
  258.     }
  259.  
  260.     if (!db_rcheader(rptr)) {
  261.         db_done(slptr);
  262.         return (FALSE);
  263.     }
  264.  
  265.     if (!(tbuf = CALLOC(rptr->rl_size))) {
  266.         db_rcdone(rptr);
  267.         RETERR(INSMEM)
  268.     }
  269.  
  270.     tbuf[0] = ACTIVE;
  271.  
  272.     for (tcnt = 0; db_fetch(slptr); tcnt++) {
  273.  
  274.         abase = 1;
  275.         for (saptr = slptr->sl_attrs; saptr != NULL; saptr = saptr->sa_next) {
  276.             for (i = 0; i < saptr->sa_attr->at_size; i++)
  277.                 tbuf[abase + i] = saptr->sa_aptr[i];
  278.  
  279.             abase += i;
  280.         }
  281.  
  282.         if (cwrite(rptr->rl_fd,tbuf,rptr->rl_size) != rptr->rl_size) {
  283.             db_rcdone(rptr);
  284.             CFREE(tbuf);
  285.             RETERR(INSBLK)
  286.         }
  287.         rptr->rl_tcnt++;
  288.         rptr->rl_tmax++;
  289.     }
  290.  
  291.     db_done(slptr);
  292.  
  293.     if (!db_rcdone(rptr))
  294.         return (FALSE);
  295.  
  296.     pcount(tcnt,"found");
  297.  
  298.     return (TRUE);
  299. }
  300.  
  301. pcount(tcnt, mess)
  302.     int tcnt; char *mess;
  303. {
  304.     if (tcnt)
  305.         printf("[ %d records %s ]\n",tcnt,mess);
  306.     else
  307.         printf("[ No records %s ]\n",mess);
  308.     return (TRUE);
  309. }
  310.  
  311. int db_to(pfp,ext)
  312.     FILE **pfp; char *ext;
  313. {
  314.  
  315.     *pfp = STDOUT;
  316.  
  317.     if (db_token() != INTO)
  318.         return (TRUE);
  319.     db_ntoken();
  320.     if (db_ntoken() == ID)
  321.         strcat(dbv_tstring,ext);
  322.     else if (dbv_token != STRING)
  323.         { RETERR(SYNTAX) }
  324.  
  325.     if (db_scmp(dbv_tstring,"lst.rep") == 0) {
  326.         *pfp = STDLST;
  327.         return (TRUE);
  328.         }
  329.  
  330.     *pfp = &obuf;
  331.     fcreat(dbv_tstring,&obuf);
  332.  
  333.     if (*pfp == -1)
  334.         { RETERR(OUTCRE) }
  335.  
  336.     return (TRUE);
  337. }
  338.  
  339. int using(pfp,ext)
  340.  char **pfp; char *ext;
  341. {
  342.     FILE *ffd;
  343.     unsigned ffsize;
  344.  
  345.     *pfp = NULL;
  346.  
  347.     if (db_token() != USING)
  348.         return (TRUE);
  349.     db_ntoken();
  350.     if (db_ntoken() == ID)
  351.         strcat(dbv_tstring,ext);
  352.     else if (dbv_token != STRING)
  353.         { RETERR(SYNTAX) }
  354.  
  355.     if ((ffd = open(dbv_tstring,0)) == -1) {
  356.         RETERR(INPFNF)
  357.         }
  358.  
  359.     ffsize = cfsize(ffd);
  360.  
  361.     if ((*pfp = CALLOC(ffsize*128)) == NULL) {
  362.         close(ffd);
  363.         RETERR(INSMEM)
  364.         }
  365.     
  366.     if (read(ffd,*pfp,ffsize) != ffsize) {
  367.         close(ffd);
  368.         CFREE(*pfp);
  369.         RETERR(INPFNF)
  370.         }
  371.  
  372.     close(ffd);
  373.     return(TRUE);
  374. }
  375.  
  376. int table(fp,slptr)
  377.     FILE *fp; struct sel *slptr;
  378. {
  379.     int tcnt;
  380.  
  381.     for (tcnt = 0; db_fetch(slptr); tcnt++) {
  382.  
  383.         if (!tcnt)
  384.             db_thead(fp,slptr);
  385.  
  386.         db_tentry(fp,slptr);
  387.     }
  388.  
  389.     if (tcnt)
  390.         db_tfoot(fp,slptr);
  391.  
  392.     return (tcnt);
  393. }
  394.  
  395. int form(ofp,slptr,ffp)
  396.     FILE *ofp; struct sel *slptr; char *ffp;
  397. {
  398.     char aname[ANSIZE+1];
  399.     char *anptr;
  400.     int ch,tcnt,rsf,kbrep;
  401.  
  402.     char *fbs,*fhs;    /* form buffer,header start */
  403.  
  404.     fhs = fbs = ffp;    /* stash them */
  405.     kbrep = 0;    /* indicate o.k. */
  406.  
  407.     if ((ch = *ffp) == '%') {        /* see if heading */
  408.         *ffp = 0;        /* make it a null */
  409.         ffp++;
  410.         while (((ch = *ffp++) != '%') && (ch != CPMEOF))
  411.             ;
  412.         if (ch == '%') {
  413.             ffp--;
  414.             *ffp++ = 0;    /* make it a null */
  415.             fbs = ffp;    /* not if eof! */
  416.             }
  417.         }
  418.     
  419.     dbv_lnct = 0;    /* force first heading */
  420.  
  421.     for (tcnt = 0; db_fetch(slptr); tcnt++) {
  422.  
  423.         if (dbv_lnct == 0) {
  424.             dbv_lnct = dbv_pgln;
  425.             dbv_page++;
  426.             ffp = fhs;
  427.         } else
  428.             ffp = fbs;    /* reposition at start */
  429.         dbv_lnct--;
  430.  
  431.         while ((ch = *ffp++) != CPMEOF)
  432.             if ((ch == '<') || (ch == '>')) {
  433.                 rsf = FALSE;
  434.                 anptr = &aname;
  435.                 while (((ch = *ffp++) != '>') && (ch != '<')
  436.                     && (ch != CPMEOF))
  437.                     if (!isspace(ch))
  438.                         *anptr++ = ch;
  439.                 if (ch == '>') rsf = TRUE;
  440.                 *anptr = 0;
  441.                 if (aname[0] == '#')
  442.                     fprintf(ofp,"%d",dbv_page);
  443.                 else
  444.                     put_avalue(ofp,slptr,aname,rsf);
  445.             }
  446.             else if (ch == '?') {        /* indicates pause */
  447.                 printf("Press ENTER to continue, ^Z to abort\n");
  448.                 kbrep = getchar();
  449.             }
  450.             else
  451.                 putc(ch,ofp);
  452.         if (kbrep == -1) break;
  453.     }
  454.  
  455.     return (tcnt);
  456. }
  457.  
  458. put_avalue(fp,slptr,aname,rsf)
  459.     char *fp; struct sel *slptr; char *aname; int rsf;
  460. {
  461.     struct sattr *saptr;
  462.     char *saname;
  463.     int i,fpd;
  464.  
  465.     for (saptr = slptr->sl_attrs; saptr ; saptr = saptr->sa_next) {
  466.  
  467.         if (!(saname = saptr->sa_name))
  468.             saname = saptr->sa_aname;
  469.         if (!db_scmp(saname,aname))
  470.             break;
  471.     }
  472.  
  473.     if (!saptr) {
  474.         fprintf(fp,"<*****>");
  475.         return;
  476.     }
  477.  
  478.     fpd = FALSE;
  479.     for (i = 0; i < saptr->sa_attr->at_size; i++) 
  480.         if (saptr->sa_aptr[i]) {
  481.             if (saptr->sa_aptr[i] == ' ') {
  482.                 if ((rsf) || (fpd))
  483.                     putc(saptr->sa_aptr[i],fp);
  484.                 }
  485.             else {            
  486.                 putc(saptr->sa_aptr[i],fp);
  487.                 fpd = TRUE;
  488.                 }
  489.             }
  490.         else
  491.             if (rsf)
  492.             putc(' ',fp);
  493. }
  494.  
  495. }
  496.             else {            
  497.                 putc(saptr->sa_aptr[i],fp);
  498.                 fpd = TRUE;